"""
集合之不可变集合 frozenset 介绍
"""

# 1. frozenset 使用说明。通过打印到控制台的信息可知，其没有删除、增加和更新等操作
print(dir(frozenset))

# 2. 关于容器的拷贝说明。深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。浅拷贝：获取的是引用，深拷贝：获取的是复制实体
# 返回列表的浅拷贝
print(help(list.copy))
# D.copy() -> D的一个浅拷贝
print(help(dict.copy))
# 返回set的浅拷贝
print(help(set.copy))
# 列表示例
b_ = [1, '2', [1, 2, 3], {'a': 1, 'b': 2}, {1, 2, 3, 4}]
copy = b_.copy()
# 内容对比（内容相同）
print(b_)
print(copy)
# 通过 == 判断内容是否相等
print(b_ == copy)
# 内存地址对比（地址不同，说明不是同一个对象）
print(id(b_))
print(id(copy))
# 也可以通过 is 关键字来判断是否是同一对象（不是同一对象。 == 是用来判断内容是否相等，is 是用来判断对象是否相同的）
print(b_ is copy)
# 对象中的元素是否是同一对象（是同一对象）
print(b_[0] is copy[0])
print(b_[1] is copy[1])
print(b_[2] is copy[2])
print(b_[3] is copy[3])
print(b_[4] is copy[4])
# 修改值为整形（修改不影响）
b_[0] = '我修改了'
print(b_)
print(copy)
# 修改值为字符串（修改不影响）
copy[1] = 111
print(b_)
print(copy)
# 修改值为列表（修改受影响）
b_[2][0] = 222
print(b_)
print(copy)
# 修改值为字典（修改受影响）
copy[3]['a'] = 333
print(b_)
print(copy)
# 修改值为集合（修改受影响）
b_[4].remove(4)
print(b_)
print(copy)
# 通过上面修改过程可知，默认的浅拷贝只能复制第一层，如果是容器类的可变对象（例如 列表、字典和集合），容器内的元素并没有被复制，所以修改会受影响

# 3. 通过引入深拷贝模块，实现深拷贝
import copy
# 对任意Python对象进行深度复制操作
print(help(copy.deepcopy))
a_b_ = [1, '2', [1, 2, 3], {'a': 1, 'b': 2}, {1, 2, 3, 4}]
deepcopy = copy.deepcopy(a_b_)
a_b_[2][1] = 111
deepcopy[3]['b'] = 222
print(a_b_)
print(deepcopy)

# 4. 集合之间关系
s = {1, 2, 3, 4, 5, 6, 7}
s1 = {3, 4, 5, 6}
# 超集判断
print(s.issuperset(s1))
print(s1.issuperset(s))
# 自己是自己的超集
print(s.issuperset(s))
print(s.issuperset(s))
# 子集判断
print(s1.issubset(s))
print(s.issubset(s1))
# 自己是自己的子集
print(s.issubset(s))
print(s1.issubset(s1))

# 5. 集合之间的运算
s2 = {1, 2, 3}
s3 = {3, 5, 6}
# 并集
s_ = s2 | s3
print(s_)
# 使用 union 函数计算并集
union = s2.union(s3)
print(union)
# 交集
s_s_ = s2 & s3
print(s_s_)
# 使用 intersection 函数计算交集
intersection = s2.intersection(s3)
print(intersection)
# 差集
s_1 = s2 - s3
print(s_1)
# 集合的顺序影响差集的结果
s_2 = s3 - s2
print(s_2)
# 使用 difference 函数计算差集
difference = s2.difference(s3)
print(difference)
# 集合的顺序影响差集的结果
s__difference = s3.difference(s2)
print(s__difference)
